//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS LicenseManager service.
///
/// License Manager makes it easier to manage licenses from software vendors across multiple  Amazon Web Services accounts and on-premises servers.
public struct LicenseManager: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the LicenseManager client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            amzTarget: "AWSLicenseManager",
            serviceName: "LicenseManager",
            serviceIdentifier: "license-manager",
            serviceProtocol: .json(version: "1.1"),
            apiVersion: "2018-08-01",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: LicenseManagerErrorType.self,
            xmlNamespace: "https://license-manager.amazonaws.com/doc/2018_08_01",
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.fips]: .init(endpoints: [
            "us-east-1": "license-manager-fips.us-east-1.amazonaws.com",
            "us-east-2": "license-manager-fips.us-east-2.amazonaws.com",
            "us-gov-east-1": "license-manager-fips.us-gov-east-1.amazonaws.com",
            "us-gov-west-1": "license-manager-fips.us-gov-west-1.amazonaws.com",
            "us-west-1": "license-manager-fips.us-west-1.amazonaws.com",
            "us-west-2": "license-manager-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Accepts the specified grant.
    @Sendable
    @inlinable
    public func acceptGrant(_ input: AcceptGrantRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AcceptGrantResponse {
        try await self.client.execute(
            operation: "AcceptGrant", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Accepts the specified grant.
    ///
    /// Parameters:
    ///   - grantArn: Amazon Resource Name (ARN) of the grant.
    ///   - logger: Logger use during operation
    @inlinable
    public func acceptGrant(
        grantArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AcceptGrantResponse {
        let input = AcceptGrantRequest(
            grantArn: grantArn
        )
        return try await self.acceptGrant(input, logger: logger)
    }

    /// Checks in the specified license. Check in a license when it is no longer in use.
    @Sendable
    @inlinable
    public func checkInLicense(_ input: CheckInLicenseRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CheckInLicenseResponse {
        try await self.client.execute(
            operation: "CheckInLicense", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Checks in the specified license. Check in a license when it is no longer in use.
    ///
    /// Parameters:
    ///   - beneficiary: License beneficiary.
    ///   - licenseConsumptionToken: License consumption token.
    ///   - logger: Logger use during operation
    @inlinable
    public func checkInLicense(
        beneficiary: String? = nil,
        licenseConsumptionToken: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CheckInLicenseResponse {
        let input = CheckInLicenseRequest(
            beneficiary: beneficiary, 
            licenseConsumptionToken: licenseConsumptionToken
        )
        return try await self.checkInLicense(input, logger: logger)
    }

    /// Checks out the specified license for offline use.
    @Sendable
    @inlinable
    public func checkoutBorrowLicense(_ input: CheckoutBorrowLicenseRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CheckoutBorrowLicenseResponse {
        try await self.client.execute(
            operation: "CheckoutBorrowLicense", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Checks out the specified license for offline use.
    ///
    /// Parameters:
    ///   - checkoutMetadata: Information about constraints.
    ///   - clientToken: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
    ///   - digitalSignatureMethod: Digital signature method. The possible value is JSON Web Signature (JWS) algorithm PS384. For more information, see RFC 7518 Digital Signature with RSASSA-PSS.
    ///   - entitlements: License entitlements. Partial checkouts are not supported.
    ///   - licenseArn: Amazon Resource Name (ARN) of the license. The license must use the borrow consumption configuration.
    ///   - nodeId: Node ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func checkoutBorrowLicense(
        checkoutMetadata: [Metadata]? = nil,
        clientToken: String,
        digitalSignatureMethod: DigitalSignatureMethod,
        entitlements: [EntitlementData],
        licenseArn: String,
        nodeId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CheckoutBorrowLicenseResponse {
        let input = CheckoutBorrowLicenseRequest(
            checkoutMetadata: checkoutMetadata, 
            clientToken: clientToken, 
            digitalSignatureMethod: digitalSignatureMethod, 
            entitlements: entitlements, 
            licenseArn: licenseArn, 
            nodeId: nodeId
        )
        return try await self.checkoutBorrowLicense(input, logger: logger)
    }

    /// Checks out the specified license.  If the account that created the license is the same that is performing the check out, you must specify the account as the beneficiary.
    @Sendable
    @inlinable
    public func checkoutLicense(_ input: CheckoutLicenseRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CheckoutLicenseResponse {
        try await self.client.execute(
            operation: "CheckoutLicense", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Checks out the specified license.  If the account that created the license is the same that is performing the check out, you must specify the account as the beneficiary.
    ///
    /// Parameters:
    ///   - beneficiary: License beneficiary.
    ///   - checkoutType: Checkout type.
    ///   - clientToken: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
    ///   - entitlements: License entitlements.
    ///   - keyFingerprint: Key fingerprint identifying the license.
    ///   - nodeId: Node ID.
    ///   - productSKU: Product SKU.
    ///   - logger: Logger use during operation
    @inlinable
    public func checkoutLicense(
        beneficiary: String? = nil,
        checkoutType: CheckoutType,
        clientToken: String,
        entitlements: [EntitlementData],
        keyFingerprint: String,
        nodeId: String? = nil,
        productSKU: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CheckoutLicenseResponse {
        let input = CheckoutLicenseRequest(
            beneficiary: beneficiary, 
            checkoutType: checkoutType, 
            clientToken: clientToken, 
            entitlements: entitlements, 
            keyFingerprint: keyFingerprint, 
            nodeId: nodeId, 
            productSKU: productSKU
        )
        return try await self.checkoutLicense(input, logger: logger)
    }

    /// Creates a grant for the specified license. A grant shares the use of license entitlements with a specific Amazon Web Services account, an organization, or an organizational unit (OU). For more information, see Granted licenses in License Manager in the License Manager User Guide.
    @Sendable
    @inlinable
    public func createGrant(_ input: CreateGrantRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateGrantResponse {
        try await self.client.execute(
            operation: "CreateGrant", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a grant for the specified license. A grant shares the use of license entitlements with a specific Amazon Web Services account, an organization, or an organizational unit (OU). For more information, see Granted licenses in License Manager in the License Manager User Guide.
    ///
    /// Parameters:
    ///   - allowedOperations: Allowed operations for the grant.
    ///   - clientToken: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
    ///   - grantName: Grant name.
    ///   - homeRegion: Home Region of the grant.
    ///   - licenseArn: Amazon Resource Name (ARN) of the license.
    ///   - principals: The grant principals. You can specify one of the following as an Amazon Resource Name (ARN):   An Amazon Web Services account, which includes only the account specified.     An organizational unit (OU), which includes all accounts in the OU.     An organization, which will include all accounts across your organization.
    ///   - tags: Tags to add to the grant. For more information about tagging support in License Manager, see the TagResource operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func createGrant(
        allowedOperations: [AllowedOperation],
        clientToken: String,
        grantName: String,
        homeRegion: String,
        licenseArn: String,
        principals: [String],
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateGrantResponse {
        let input = CreateGrantRequest(
            allowedOperations: allowedOperations, 
            clientToken: clientToken, 
            grantName: grantName, 
            homeRegion: homeRegion, 
            licenseArn: licenseArn, 
            principals: principals, 
            tags: tags
        )
        return try await self.createGrant(input, logger: logger)
    }

    /// Creates a new version of the specified grant. For more information, see Granted licenses in License Manager in the License Manager User Guide.
    @Sendable
    @inlinable
    public func createGrantVersion(_ input: CreateGrantVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateGrantVersionResponse {
        try await self.client.execute(
            operation: "CreateGrantVersion", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new version of the specified grant. For more information, see Granted licenses in License Manager in the License Manager User Guide.
    ///
    /// Parameters:
    ///   - allowedOperations: Allowed operations for the grant.
    ///   - clientToken: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
    ///   - grantArn: Amazon Resource Name (ARN) of the grant.
    ///   - grantName: Grant name.
    ///   - options: The options specified for the grant.
    ///   - sourceVersion: Current version of the grant.
    ///   - status: Grant status.
    ///   - statusReason: Grant status reason.
    ///   - logger: Logger use during operation
    @inlinable
    public func createGrantVersion(
        allowedOperations: [AllowedOperation]? = nil,
        clientToken: String,
        grantArn: String,
        grantName: String? = nil,
        options: Options? = nil,
        sourceVersion: String? = nil,
        status: GrantStatus? = nil,
        statusReason: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateGrantVersionResponse {
        let input = CreateGrantVersionRequest(
            allowedOperations: allowedOperations, 
            clientToken: clientToken, 
            grantArn: grantArn, 
            grantName: grantName, 
            options: options, 
            sourceVersion: sourceVersion, 
            status: status, 
            statusReason: statusReason
        )
        return try await self.createGrantVersion(input, logger: logger)
    }

    /// Creates a license.
    @Sendable
    @inlinable
    public func createLicense(_ input: CreateLicenseRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateLicenseResponse {
        try await self.client.execute(
            operation: "CreateLicense", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a license.
    ///
    /// Parameters:
    ///   - beneficiary: License beneficiary.
    ///   - clientToken: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
    ///   - consumptionConfiguration: Configuration for consumption of the license. Choose a provisional configuration for workloads running with continuous connectivity. Choose a borrow configuration for workloads with offline usage.
    ///   - entitlements: License entitlements.
    ///   - homeRegion: Home Region for the license.
    ///   - issuer: License issuer.
    ///   - licenseMetadata: Information about the license.
    ///   - licenseName: License name.
    ///   - productName: Product name.
    ///   - productSKU: Product SKU.
    ///   - tags: Tags to add to the license. For more information about tagging support in License Manager, see the TagResource operation.
    ///   - validity: Date and time range during which the license is valid, in ISO8601-UTC format.
    ///   - logger: Logger use during operation
    @inlinable
    public func createLicense(
        beneficiary: String,
        clientToken: String,
        consumptionConfiguration: ConsumptionConfiguration,
        entitlements: [Entitlement],
        homeRegion: String,
        issuer: Issuer,
        licenseMetadata: [Metadata]? = nil,
        licenseName: String,
        productName: String,
        productSKU: String,
        tags: [Tag]? = nil,
        validity: DatetimeRange,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateLicenseResponse {
        let input = CreateLicenseRequest(
            beneficiary: beneficiary, 
            clientToken: clientToken, 
            consumptionConfiguration: consumptionConfiguration, 
            entitlements: entitlements, 
            homeRegion: homeRegion, 
            issuer: issuer, 
            licenseMetadata: licenseMetadata, 
            licenseName: licenseName, 
            productName: productName, 
            productSKU: productSKU, 
            tags: tags, 
            validity: validity
        )
        return try await self.createLicense(input, logger: logger)
    }

    /// Creates a license configuration. A license configuration is an abstraction of a customer license agreement that can be consumed and enforced by License Manager. Components include specifications for the license type (licensing by instance, socket, CPU, or vCPU), allowed tenancy (shared tenancy,  Dedicated Instance, Dedicated Host, or all of these), license affinity  to host (how long a  license must be associated with a host), and the number of licenses purchased and used.
    @Sendable
    @inlinable
    public func createLicenseConfiguration(_ input: CreateLicenseConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateLicenseConfigurationResponse {
        try await self.client.execute(
            operation: "CreateLicenseConfiguration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a license configuration. A license configuration is an abstraction of a customer license agreement that can be consumed and enforced by License Manager. Components include specifications for the license type (licensing by instance, socket, CPU, or vCPU), allowed tenancy (shared tenancy,  Dedicated Instance, Dedicated Host, or all of these), license affinity  to host (how long a  license must be associated with a host), and the number of licenses purchased and used.
    ///
    /// Parameters:
    ///   - description: Description of the license configuration.
    ///   - disassociateWhenNotFound: When true, disassociates a resource when software is uninstalled.
    ///   - licenseCount: Number of licenses managed by the license configuration.
    ///   - licenseCountHardLimit: Indicates whether hard or soft license enforcement is used. Exceeding a hard limit blocks the launch of new instances.
    ///   - licenseCountingType: Dimension used to track the license inventory.
    ///   - licenseRules: License rules. The syntax is #name=value (for example, #allowedTenancy=EC2-DedicatedHost). The available rules  vary by dimension, as follows.    Cores dimension: allowedTenancy | licenseAffinityToHost | maximumCores | minimumCores     Instances dimension: allowedTenancy |  maximumVcpus | minimumVcpus     Sockets dimension: allowedTenancy |  licenseAffinityToHost | maximumSockets | minimumSockets     vCPUs dimension: allowedTenancy |  honorVcpuOptimization |  maximumVcpus | minimumVcpus    The unit for licenseAffinityToHost is days and the range is 1 to 180. The possible  values for allowedTenancy are EC2-Default, EC2-DedicatedHost, and  EC2-DedicatedInstance. The possible values for honorVcpuOptimization are  True and False.
    ///   - name: Name of the license configuration.
    ///   - productInformationList: Product information.
    ///   - tags: Tags to add to the license configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func createLicenseConfiguration(
        description: String? = nil,
        disassociateWhenNotFound: Bool? = nil,
        licenseCount: Int64? = nil,
        licenseCountHardLimit: Bool? = nil,
        licenseCountingType: LicenseCountingType,
        licenseRules: [String]? = nil,
        name: String,
        productInformationList: [ProductInformation]? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateLicenseConfigurationResponse {
        let input = CreateLicenseConfigurationRequest(
            description: description, 
            disassociateWhenNotFound: disassociateWhenNotFound, 
            licenseCount: licenseCount, 
            licenseCountHardLimit: licenseCountHardLimit, 
            licenseCountingType: licenseCountingType, 
            licenseRules: licenseRules, 
            name: name, 
            productInformationList: productInformationList, 
            tags: tags
        )
        return try await self.createLicenseConfiguration(input, logger: logger)
    }

    /// Creates a new license conversion task.
    @Sendable
    @inlinable
    public func createLicenseConversionTaskForResource(_ input: CreateLicenseConversionTaskForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateLicenseConversionTaskForResourceResponse {
        try await self.client.execute(
            operation: "CreateLicenseConversionTaskForResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new license conversion task.
    ///
    /// Parameters:
    ///   - destinationLicenseContext: Information that identifies the license type you are converting to. For the structure of the destination license, see Convert a license type using the CLI  in the License Manager User Guide.
    ///   - resourceArn: Amazon Resource Name (ARN) of the resource you are converting the license type for.
    ///   - sourceLicenseContext: Information that identifies the license type you are converting from.
    ///   - logger: Logger use during operation
    @inlinable
    public func createLicenseConversionTaskForResource(
        destinationLicenseContext: LicenseConversionContext,
        resourceArn: String,
        sourceLicenseContext: LicenseConversionContext,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateLicenseConversionTaskForResourceResponse {
        let input = CreateLicenseConversionTaskForResourceRequest(
            destinationLicenseContext: destinationLicenseContext, 
            resourceArn: resourceArn, 
            sourceLicenseContext: sourceLicenseContext
        )
        return try await self.createLicenseConversionTaskForResource(input, logger: logger)
    }

    /// Creates a report generator.
    @Sendable
    @inlinable
    public func createLicenseManagerReportGenerator(_ input: CreateLicenseManagerReportGeneratorRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateLicenseManagerReportGeneratorResponse {
        try await self.client.execute(
            operation: "CreateLicenseManagerReportGenerator", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a report generator.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
    ///   - description: Description of the report generator.
    ///   - reportContext: Defines the type of license configuration the report generator tracks.
    ///   - reportFrequency: Frequency by which reports are generated.  Reports can be generated daily, monthly, or weekly.
    ///   - reportGeneratorName: Name of the report generator.
    ///   - tags: Tags to add to the report generator.
    ///   - type: Type of reports to generate. The following report types an be generated:   License configuration report - Reports the number and details of consumed licenses for a license configuration.   Resource report - Reports the tracked licenses and resource consumption for a license configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func createLicenseManagerReportGenerator(
        clientToken: String,
        description: String? = nil,
        reportContext: ReportContext,
        reportFrequency: ReportFrequency,
        reportGeneratorName: String,
        tags: [Tag]? = nil,
        type: [ReportType],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateLicenseManagerReportGeneratorResponse {
        let input = CreateLicenseManagerReportGeneratorRequest(
            clientToken: clientToken, 
            description: description, 
            reportContext: reportContext, 
            reportFrequency: reportFrequency, 
            reportGeneratorName: reportGeneratorName, 
            tags: tags, 
            type: type
        )
        return try await self.createLicenseManagerReportGenerator(input, logger: logger)
    }

    /// Creates a new version of the specified license.
    @Sendable
    @inlinable
    public func createLicenseVersion(_ input: CreateLicenseVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateLicenseVersionResponse {
        try await self.client.execute(
            operation: "CreateLicenseVersion", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new version of the specified license.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
    ///   - consumptionConfiguration: Configuration for consumption of the license. Choose a provisional configuration for workloads running with continuous connectivity. Choose a borrow configuration for workloads with offline usage.
    ///   - entitlements: License entitlements.
    ///   - homeRegion: Home Region of the license.
    ///   - issuer: License issuer.
    ///   - licenseArn: Amazon Resource Name (ARN) of the license.
    ///   - licenseMetadata: Information about the license.
    ///   - licenseName: License name.
    ///   - productName: Product name.
    ///   - sourceVersion: Current version of the license.
    ///   - status: License status.
    ///   - validity: Date and time range during which the license is valid, in ISO8601-UTC format.
    ///   - logger: Logger use during operation
    @inlinable
    public func createLicenseVersion(
        clientToken: String,
        consumptionConfiguration: ConsumptionConfiguration,
        entitlements: [Entitlement],
        homeRegion: String,
        issuer: Issuer,
        licenseArn: String,
        licenseMetadata: [Metadata]? = nil,
        licenseName: String,
        productName: String,
        sourceVersion: String? = nil,
        status: LicenseStatus,
        validity: DatetimeRange,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateLicenseVersionResponse {
        let input = CreateLicenseVersionRequest(
            clientToken: clientToken, 
            consumptionConfiguration: consumptionConfiguration, 
            entitlements: entitlements, 
            homeRegion: homeRegion, 
            issuer: issuer, 
            licenseArn: licenseArn, 
            licenseMetadata: licenseMetadata, 
            licenseName: licenseName, 
            productName: productName, 
            sourceVersion: sourceVersion, 
            status: status, 
            validity: validity
        )
        return try await self.createLicenseVersion(input, logger: logger)
    }

    /// Creates a long-lived token. A refresh token is a JWT token used to get an access token. With an access token, you can call AssumeRoleWithWebIdentity to get role credentials that you can use to  call License Manager to manage the specified license.
    @Sendable
    @inlinable
    public func createToken(_ input: CreateTokenRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateTokenResponse {
        try await self.client.execute(
            operation: "CreateToken", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a long-lived token. A refresh token is a JWT token used to get an access token. With an access token, you can call AssumeRoleWithWebIdentity to get role credentials that you can use to  call License Manager to manage the specified license.
    ///
    /// Parameters:
    ///   - clientToken: Idempotency token, valid for 10 minutes.
    ///   - expirationInDays: Token expiration, in days, counted from token creation. The default is 365 days.
    ///   - licenseArn: Amazon Resource Name (ARN) of the license. The ARN is mapped to the aud claim of the JWT token.
    ///   - roleArns: Amazon Resource Name (ARN) of the IAM roles to embed in the token.  License Manager does not check whether the roles are in use.
    ///   - tokenProperties: Data specified by the caller to be included in the JWT token. The data is mapped to the amr claim of the JWT token.
    ///   - logger: Logger use during operation
    @inlinable
    public func createToken(
        clientToken: String,
        expirationInDays: Int? = nil,
        licenseArn: String,
        roleArns: [String]? = nil,
        tokenProperties: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateTokenResponse {
        let input = CreateTokenRequest(
            clientToken: clientToken, 
            expirationInDays: expirationInDays, 
            licenseArn: licenseArn, 
            roleArns: roleArns, 
            tokenProperties: tokenProperties
        )
        return try await self.createToken(input, logger: logger)
    }

    /// Deletes the specified grant.
    @Sendable
    @inlinable
    public func deleteGrant(_ input: DeleteGrantRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteGrantResponse {
        try await self.client.execute(
            operation: "DeleteGrant", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified grant.
    ///
    /// Parameters:
    ///   - grantArn: Amazon Resource Name (ARN) of the grant.
    ///   - statusReason: The Status reason for the delete request.
    ///   - version: Current version of the grant.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteGrant(
        grantArn: String,
        statusReason: String? = nil,
        version: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteGrantResponse {
        let input = DeleteGrantRequest(
            grantArn: grantArn, 
            statusReason: statusReason, 
            version: version
        )
        return try await self.deleteGrant(input, logger: logger)
    }

    /// Deletes the specified license.
    @Sendable
    @inlinable
    public func deleteLicense(_ input: DeleteLicenseRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteLicenseResponse {
        try await self.client.execute(
            operation: "DeleteLicense", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified license.
    ///
    /// Parameters:
    ///   - licenseArn: Amazon Resource Name (ARN) of the license.
    ///   - sourceVersion: Current version of the license.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteLicense(
        licenseArn: String,
        sourceVersion: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteLicenseResponse {
        let input = DeleteLicenseRequest(
            licenseArn: licenseArn, 
            sourceVersion: sourceVersion
        )
        return try await self.deleteLicense(input, logger: logger)
    }

    /// Deletes the specified license configuration. You cannot delete a license configuration that is in use.
    @Sendable
    @inlinable
    public func deleteLicenseConfiguration(_ input: DeleteLicenseConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteLicenseConfigurationResponse {
        try await self.client.execute(
            operation: "DeleteLicenseConfiguration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified license configuration. You cannot delete a license configuration that is in use.
    ///
    /// Parameters:
    ///   - licenseConfigurationArn: ID of the license configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteLicenseConfiguration(
        licenseConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteLicenseConfigurationResponse {
        let input = DeleteLicenseConfigurationRequest(
            licenseConfigurationArn: licenseConfigurationArn
        )
        return try await self.deleteLicenseConfiguration(input, logger: logger)
    }

    /// Deletes the specified report generator. This action deletes the report generator, which stops it from generating future reports. The action cannot be reversed. It has no effect on the previous reports from this generator.
    @Sendable
    @inlinable
    public func deleteLicenseManagerReportGenerator(_ input: DeleteLicenseManagerReportGeneratorRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteLicenseManagerReportGeneratorResponse {
        try await self.client.execute(
            operation: "DeleteLicenseManagerReportGenerator", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified report generator. This action deletes the report generator, which stops it from generating future reports. The action cannot be reversed. It has no effect on the previous reports from this generator.
    ///
    /// Parameters:
    ///   - licenseManagerReportGeneratorArn: Amazon Resource Name (ARN) of the report generator to be deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteLicenseManagerReportGenerator(
        licenseManagerReportGeneratorArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteLicenseManagerReportGeneratorResponse {
        let input = DeleteLicenseManagerReportGeneratorRequest(
            licenseManagerReportGeneratorArn: licenseManagerReportGeneratorArn
        )
        return try await self.deleteLicenseManagerReportGenerator(input, logger: logger)
    }

    /// Deletes the specified token. Must be called in the license home Region.
    @Sendable
    @inlinable
    public func deleteToken(_ input: DeleteTokenRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteTokenResponse {
        try await self.client.execute(
            operation: "DeleteToken", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified token. Must be called in the license home Region.
    ///
    /// Parameters:
    ///   - tokenId: Token ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteToken(
        tokenId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteTokenResponse {
        let input = DeleteTokenRequest(
            tokenId: tokenId
        )
        return try await self.deleteToken(input, logger: logger)
    }

    /// Extends the expiration date for license consumption.
    @Sendable
    @inlinable
    public func extendLicenseConsumption(_ input: ExtendLicenseConsumptionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ExtendLicenseConsumptionResponse {
        try await self.client.execute(
            operation: "ExtendLicenseConsumption", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Extends the expiration date for license consumption.
    ///
    /// Parameters:
    ///   - dryRun: Checks whether you have the required permissions for the action, without actually making the request. Provides an error response if you do not have the required permissions.
    ///   - licenseConsumptionToken: License consumption token.
    ///   - logger: Logger use during operation
    @inlinable
    public func extendLicenseConsumption(
        dryRun: Bool? = nil,
        licenseConsumptionToken: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ExtendLicenseConsumptionResponse {
        let input = ExtendLicenseConsumptionRequest(
            dryRun: dryRun, 
            licenseConsumptionToken: licenseConsumptionToken
        )
        return try await self.extendLicenseConsumption(input, logger: logger)
    }

    /// Gets a temporary access token to use with AssumeRoleWithWebIdentity. Access tokens are valid for one hour.
    @Sendable
    @inlinable
    public func getAccessToken(_ input: GetAccessTokenRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAccessTokenResponse {
        try await self.client.execute(
            operation: "GetAccessToken", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets a temporary access token to use with AssumeRoleWithWebIdentity. Access tokens are valid for one hour.
    ///
    /// Parameters:
    ///   - token: Refresh token, encoded as a JWT token.
    ///   - tokenProperties: Token properties to validate against those present in the JWT token.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAccessToken(
        token: String,
        tokenProperties: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAccessTokenResponse {
        let input = GetAccessTokenRequest(
            token: token, 
            tokenProperties: tokenProperties
        )
        return try await self.getAccessToken(input, logger: logger)
    }

    /// Gets detailed information about the specified grant.
    @Sendable
    @inlinable
    public func getGrant(_ input: GetGrantRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetGrantResponse {
        try await self.client.execute(
            operation: "GetGrant", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets detailed information about the specified grant.
    ///
    /// Parameters:
    ///   - grantArn: Amazon Resource Name (ARN) of the grant.
    ///   - version: Grant version.
    ///   - logger: Logger use during operation
    @inlinable
    public func getGrant(
        grantArn: String,
        version: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetGrantResponse {
        let input = GetGrantRequest(
            grantArn: grantArn, 
            version: version
        )
        return try await self.getGrant(input, logger: logger)
    }

    /// Gets detailed information about the specified license.
    @Sendable
    @inlinable
    public func getLicense(_ input: GetLicenseRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetLicenseResponse {
        try await self.client.execute(
            operation: "GetLicense", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets detailed information about the specified license.
    ///
    /// Parameters:
    ///   - licenseArn: Amazon Resource Name (ARN) of the license.
    ///   - version: License version.
    ///   - logger: Logger use during operation
    @inlinable
    public func getLicense(
        licenseArn: String,
        version: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetLicenseResponse {
        let input = GetLicenseRequest(
            licenseArn: licenseArn, 
            version: version
        )
        return try await self.getLicense(input, logger: logger)
    }

    /// Gets detailed information about the specified license configuration.
    @Sendable
    @inlinable
    public func getLicenseConfiguration(_ input: GetLicenseConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetLicenseConfigurationResponse {
        try await self.client.execute(
            operation: "GetLicenseConfiguration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets detailed information about the specified license configuration.
    ///
    /// Parameters:
    ///   - licenseConfigurationArn: Amazon Resource Name (ARN) of the license configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func getLicenseConfiguration(
        licenseConfigurationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetLicenseConfigurationResponse {
        let input = GetLicenseConfigurationRequest(
            licenseConfigurationArn: licenseConfigurationArn
        )
        return try await self.getLicenseConfiguration(input, logger: logger)
    }

    /// Gets information about the specified license type conversion task.
    @Sendable
    @inlinable
    public func getLicenseConversionTask(_ input: GetLicenseConversionTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetLicenseConversionTaskResponse {
        try await self.client.execute(
            operation: "GetLicenseConversionTask", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about the specified license type conversion task.
    ///
    /// Parameters:
    ///   - licenseConversionTaskId: ID of the license type conversion task to retrieve information on.
    ///   - logger: Logger use during operation
    @inlinable
    public func getLicenseConversionTask(
        licenseConversionTaskId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetLicenseConversionTaskResponse {
        let input = GetLicenseConversionTaskRequest(
            licenseConversionTaskId: licenseConversionTaskId
        )
        return try await self.getLicenseConversionTask(input, logger: logger)
    }

    /// Gets information about the specified report generator.
    @Sendable
    @inlinable
    public func getLicenseManagerReportGenerator(_ input: GetLicenseManagerReportGeneratorRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetLicenseManagerReportGeneratorResponse {
        try await self.client.execute(
            operation: "GetLicenseManagerReportGenerator", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about the specified report generator.
    ///
    /// Parameters:
    ///   - licenseManagerReportGeneratorArn: Amazon Resource Name (ARN) of the report generator.
    ///   - logger: Logger use during operation
    @inlinable
    public func getLicenseManagerReportGenerator(
        licenseManagerReportGeneratorArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetLicenseManagerReportGeneratorResponse {
        let input = GetLicenseManagerReportGeneratorRequest(
            licenseManagerReportGeneratorArn: licenseManagerReportGeneratorArn
        )
        return try await self.getLicenseManagerReportGenerator(input, logger: logger)
    }

    /// Gets detailed information about the usage of the specified license.
    @Sendable
    @inlinable
    public func getLicenseUsage(_ input: GetLicenseUsageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetLicenseUsageResponse {
        try await self.client.execute(
            operation: "GetLicenseUsage", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets detailed information about the usage of the specified license.
    ///
    /// Parameters:
    ///   - licenseArn: Amazon Resource Name (ARN) of the license.
    ///   - logger: Logger use during operation
    @inlinable
    public func getLicenseUsage(
        licenseArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetLicenseUsageResponse {
        let input = GetLicenseUsageRequest(
            licenseArn: licenseArn
        )
        return try await self.getLicenseUsage(input, logger: logger)
    }

    /// Gets the License Manager settings for the current Region.
    @Sendable
    @inlinable
    public func getServiceSettings(_ input: GetServiceSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetServiceSettingsResponse {
        try await self.client.execute(
            operation: "GetServiceSettings", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the License Manager settings for the current Region.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getServiceSettings(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetServiceSettingsResponse {
        let input = GetServiceSettingsRequest(
        )
        return try await self.getServiceSettings(input, logger: logger)
    }

    /// Lists the resource associations for the specified license configuration. Resource associations need not consume licenses from a license configuration.  For example, an AMI or a stopped instance might not consume a license (depending on  the license rules).
    @Sendable
    @inlinable
    public func listAssociationsForLicenseConfiguration(_ input: ListAssociationsForLicenseConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAssociationsForLicenseConfigurationResponse {
        try await self.client.execute(
            operation: "ListAssociationsForLicenseConfiguration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the resource associations for the specified license configuration. Resource associations need not consume licenses from a license configuration.  For example, an AMI or a stopped instance might not consume a license (depending on  the license rules).
    ///
    /// Parameters:
    ///   - licenseConfigurationArn: Amazon Resource Name (ARN) of a license configuration.
    ///   - maxResults: Maximum number of results to return in a single call.
    ///   - nextToken: Token for the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAssociationsForLicenseConfiguration(
        licenseConfigurationArn: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAssociationsForLicenseConfigurationResponse {
        let input = ListAssociationsForLicenseConfigurationRequest(
            licenseConfigurationArn: licenseConfigurationArn, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAssociationsForLicenseConfiguration(input, logger: logger)
    }

    /// Lists the grants distributed for the specified license.
    @Sendable
    @inlinable
    public func listDistributedGrants(_ input: ListDistributedGrantsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDistributedGrantsResponse {
        try await self.client.execute(
            operation: "ListDistributedGrants", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the grants distributed for the specified license.
    ///
    /// Parameters:
    ///   - filters: Filters to scope the results. The following filters are supported:    LicenseArn     GrantStatus     GranteePrincipalARN     ProductSKU     LicenseIssuerName
    ///   - grantArns: Amazon Resource Names (ARNs) of the grants.
    ///   - maxResults: Maximum number of results to return in a single call.
    ///   - nextToken: Token for the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDistributedGrants(
        filters: [Filter]? = nil,
        grantArns: [String]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDistributedGrantsResponse {
        let input = ListDistributedGrantsRequest(
            filters: filters, 
            grantArns: grantArns, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDistributedGrants(input, logger: logger)
    }

    /// Lists the license configuration operations that failed.
    @Sendable
    @inlinable
    public func listFailuresForLicenseConfigurationOperations(_ input: ListFailuresForLicenseConfigurationOperationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListFailuresForLicenseConfigurationOperationsResponse {
        try await self.client.execute(
            operation: "ListFailuresForLicenseConfigurationOperations", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the license configuration operations that failed.
    ///
    /// Parameters:
    ///   - licenseConfigurationArn: Amazon Resource Name of the license configuration.
    ///   - maxResults: Maximum number of results to return in a single call.
    ///   - nextToken: Token for the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listFailuresForLicenseConfigurationOperations(
        licenseConfigurationArn: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListFailuresForLicenseConfigurationOperationsResponse {
        let input = ListFailuresForLicenseConfigurationOperationsRequest(
            licenseConfigurationArn: licenseConfigurationArn, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listFailuresForLicenseConfigurationOperations(input, logger: logger)
    }

    /// Lists the license configurations for your account.
    @Sendable
    @inlinable
    public func listLicenseConfigurations(_ input: ListLicenseConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListLicenseConfigurationsResponse {
        try await self.client.execute(
            operation: "ListLicenseConfigurations", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the license configurations for your account.
    ///
    /// Parameters:
    ///   - filters: Filters to scope the results. The following filters and logical operators are supported:    licenseCountingType - The dimension for which licenses are counted. Possible values are vCPU | Instance | Core | Socket.    enforceLicenseCount - A Boolean value that indicates whether hard license enforcement is used.    usagelimitExceeded - A Boolean value that indicates whether the available licenses have been exceeded.
    ///   - licenseConfigurationArns: Amazon Resource Names (ARN) of the license configurations.
    ///   - maxResults: Maximum number of results to return in a single call.
    ///   - nextToken: Token for the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listLicenseConfigurations(
        filters: [Filter]? = nil,
        licenseConfigurationArns: [String]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListLicenseConfigurationsResponse {
        let input = ListLicenseConfigurationsRequest(
            filters: filters, 
            licenseConfigurationArns: licenseConfigurationArns, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listLicenseConfigurations(input, logger: logger)
    }

    /// Lists the license type conversion tasks for your account.
    @Sendable
    @inlinable
    public func listLicenseConversionTasks(_ input: ListLicenseConversionTasksRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListLicenseConversionTasksResponse {
        try await self.client.execute(
            operation: "ListLicenseConversionTasks", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the license type conversion tasks for your account.
    ///
    /// Parameters:
    ///   - filters:  Filters to scope the results. Valid filters are ResourceArns and Status.
    ///   - maxResults: Maximum number of results to return in a single call.
    ///   - nextToken: Token for the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listLicenseConversionTasks(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListLicenseConversionTasksResponse {
        let input = ListLicenseConversionTasksRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listLicenseConversionTasks(input, logger: logger)
    }

    /// Lists the report generators for your account.
    @Sendable
    @inlinable
    public func listLicenseManagerReportGenerators(_ input: ListLicenseManagerReportGeneratorsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListLicenseManagerReportGeneratorsResponse {
        try await self.client.execute(
            operation: "ListLicenseManagerReportGenerators", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the report generators for your account.
    ///
    /// Parameters:
    ///   - filters: Filters to scope the results. The following filters are supported:     LicenseConfigurationArn
    ///   - maxResults: Maximum number of results to return in a single call.
    ///   - nextToken: Token for the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listLicenseManagerReportGenerators(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListLicenseManagerReportGeneratorsResponse {
        let input = ListLicenseManagerReportGeneratorsRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listLicenseManagerReportGenerators(input, logger: logger)
    }

    /// Describes the license configurations for the specified resource.
    @Sendable
    @inlinable
    public func listLicenseSpecificationsForResource(_ input: ListLicenseSpecificationsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListLicenseSpecificationsForResourceResponse {
        try await self.client.execute(
            operation: "ListLicenseSpecificationsForResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the license configurations for the specified resource.
    ///
    /// Parameters:
    ///   - maxResults: Maximum number of results to return in a single call.
    ///   - nextToken: Token for the next set of results.
    ///   - resourceArn: Amazon Resource Name (ARN) of a resource that has an associated license configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func listLicenseSpecificationsForResource(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListLicenseSpecificationsForResourceResponse {
        let input = ListLicenseSpecificationsForResourceRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            resourceArn: resourceArn
        )
        return try await self.listLicenseSpecificationsForResource(input, logger: logger)
    }

    /// Lists all versions of the specified license.
    @Sendable
    @inlinable
    public func listLicenseVersions(_ input: ListLicenseVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListLicenseVersionsResponse {
        try await self.client.execute(
            operation: "ListLicenseVersions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all versions of the specified license.
    ///
    /// Parameters:
    ///   - licenseArn: Amazon Resource Name (ARN) of the license.
    ///   - maxResults: Maximum number of results to return in a single call.
    ///   - nextToken: Token for the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listLicenseVersions(
        licenseArn: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListLicenseVersionsResponse {
        let input = ListLicenseVersionsRequest(
            licenseArn: licenseArn, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listLicenseVersions(input, logger: logger)
    }

    /// Lists the licenses for your account.
    @Sendable
    @inlinable
    public func listLicenses(_ input: ListLicensesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListLicensesResponse {
        try await self.client.execute(
            operation: "ListLicenses", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the licenses for your account.
    ///
    /// Parameters:
    ///   - filters: Filters to scope the results. The following filters are supported:    Beneficiary     ProductSKU     Fingerprint     Status
    ///   - licenseArns: Amazon Resource Names (ARNs) of the licenses.
    ///   - maxResults: Maximum number of results to return in a single call.
    ///   - nextToken: Token for the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listLicenses(
        filters: [Filter]? = nil,
        licenseArns: [String]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListLicensesResponse {
        let input = ListLicensesRequest(
            filters: filters, 
            licenseArns: licenseArns, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listLicenses(input, logger: logger)
    }

    /// Lists grants that are received. Received grants are grants created while specifying the recipient as this Amazon Web Services account, your organization, or an organizational unit (OU) to which this member account belongs.
    @Sendable
    @inlinable
    public func listReceivedGrants(_ input: ListReceivedGrantsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListReceivedGrantsResponse {
        try await self.client.execute(
            operation: "ListReceivedGrants", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists grants that are received. Received grants are grants created while specifying the recipient as this Amazon Web Services account, your organization, or an organizational unit (OU) to which this member account belongs.
    ///
    /// Parameters:
    ///   - filters: Filters to scope the results. The following filters are supported:    ProductSKU     LicenseIssuerName     LicenseArn     GrantStatus     GranterAccountId
    ///   - grantArns: Amazon Resource Names (ARNs) of the grants.
    ///   - maxResults: Maximum number of results to return in a single call.
    ///   - nextToken: Token for the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listReceivedGrants(
        filters: [Filter]? = nil,
        grantArns: [String]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListReceivedGrantsResponse {
        let input = ListReceivedGrantsRequest(
            filters: filters, 
            grantArns: grantArns, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listReceivedGrants(input, logger: logger)
    }

    /// Lists the grants received for all accounts in the organization.
    @Sendable
    @inlinable
    public func listReceivedGrantsForOrganization(_ input: ListReceivedGrantsForOrganizationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListReceivedGrantsForOrganizationResponse {
        try await self.client.execute(
            operation: "ListReceivedGrantsForOrganization", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the grants received for all accounts in the organization.
    ///
    /// Parameters:
    ///   - filters: Filters to scope the results. The following filters are supported:    ParentArn     GranteePrincipalArn
    ///   - licenseArn: The Amazon Resource Name (ARN) of the received license.
    ///   - maxResults: Maximum number of results to return in a single call.
    ///   - nextToken: Token for the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listReceivedGrantsForOrganization(
        filters: [Filter]? = nil,
        licenseArn: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListReceivedGrantsForOrganizationResponse {
        let input = ListReceivedGrantsForOrganizationRequest(
            filters: filters, 
            licenseArn: licenseArn, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listReceivedGrantsForOrganization(input, logger: logger)
    }

    /// Lists received licenses.
    @Sendable
    @inlinable
    public func listReceivedLicenses(_ input: ListReceivedLicensesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListReceivedLicensesResponse {
        try await self.client.execute(
            operation: "ListReceivedLicenses", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists received licenses.
    ///
    /// Parameters:
    ///   - filters: Filters to scope the results. The following filters are supported:    ProductSKU     Status     Fingerprint     IssuerName     Beneficiary
    ///   - licenseArns: Amazon Resource Names (ARNs) of the licenses.
    ///   - maxResults: Maximum number of results to return in a single call.
    ///   - nextToken: Token for the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listReceivedLicenses(
        filters: [Filter]? = nil,
        licenseArns: [String]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListReceivedLicensesResponse {
        let input = ListReceivedLicensesRequest(
            filters: filters, 
            licenseArns: licenseArns, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listReceivedLicenses(input, logger: logger)
    }

    /// Lists the licenses received for all accounts in the organization.
    @Sendable
    @inlinable
    public func listReceivedLicensesForOrganization(_ input: ListReceivedLicensesForOrganizationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListReceivedLicensesForOrganizationResponse {
        try await self.client.execute(
            operation: "ListReceivedLicensesForOrganization", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the licenses received for all accounts in the organization.
    ///
    /// Parameters:
    ///   - filters: Filters to scope the results. The following filters are supported:    Beneficiary     ProductSKU
    ///   - maxResults: Maximum number of results to return in a single call.
    ///   - nextToken: Token for the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listReceivedLicensesForOrganization(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListReceivedLicensesForOrganizationResponse {
        let input = ListReceivedLicensesForOrganizationRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listReceivedLicensesForOrganization(input, logger: logger)
    }

    /// Lists resources managed using Systems Manager inventory.
    @Sendable
    @inlinable
    public func listResourceInventory(_ input: ListResourceInventoryRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListResourceInventoryResponse {
        try await self.client.execute(
            operation: "ListResourceInventory", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists resources managed using Systems Manager inventory.
    ///
    /// Parameters:
    ///   - filters: Filters to scope the results. The following filters and logical operators are supported:    account_id - The ID of the Amazon Web Services account that owns the resource. Logical operators are EQUALS | NOT_EQUALS.    application_name - The name of the application.  Logical operators are EQUALS | BEGINS_WITH.    license_included - The type of license included.  Logical operators are EQUALS | NOT_EQUALS. Possible values are sql-server-enterprise |  sql-server-standard |  sql-server-web |   windows-server-datacenter.    platform - The platform of the resource. Logical operators are EQUALS | BEGINS_WITH.    resource_id - The ID of the resource.  Logical operators are EQUALS | NOT_EQUALS.    tag: - The key/value combination of a tag assigned  to the resource. Logical operators are EQUALS (single account) or EQUALS | NOT_EQUALS (cross account).
    ///   - maxResults: Maximum number of results to return in a single call.
    ///   - nextToken: Token for the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listResourceInventory(
        filters: [InventoryFilter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListResourceInventoryResponse {
        let input = ListResourceInventoryRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listResourceInventory(input, logger: logger)
    }

    /// Lists the tags for the specified resource. For more information about tagging support in License Manager, see the TagResource operation.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the tags for the specified resource. For more information about tagging support in License Manager, see the TagResource operation.
    ///
    /// Parameters:
    ///   - resourceArn: Amazon Resource Name (ARN) of the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Lists your tokens.
    @Sendable
    @inlinable
    public func listTokens(_ input: ListTokensRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTokensResponse {
        try await self.client.execute(
            operation: "ListTokens", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists your tokens.
    ///
    /// Parameters:
    ///   - filters: Filters to scope the results. The following filter is supported:    LicenseArns
    ///   - maxResults: Maximum number of results to return in a single call.
    ///   - nextToken: Token for the next set of results.
    ///   - tokenIds: Token IDs.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTokens(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        tokenIds: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTokensResponse {
        let input = ListTokensRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            tokenIds: tokenIds
        )
        return try await self.listTokens(input, logger: logger)
    }

    /// Lists all license usage records for a license configuration, displaying license consumption details by resource at a selected point in time. Use this action to audit the current license consumption for any license inventory and configuration.
    @Sendable
    @inlinable
    public func listUsageForLicenseConfiguration(_ input: ListUsageForLicenseConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListUsageForLicenseConfigurationResponse {
        try await self.client.execute(
            operation: "ListUsageForLicenseConfiguration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all license usage records for a license configuration, displaying license consumption details by resource at a selected point in time. Use this action to audit the current license consumption for any license inventory and configuration.
    ///
    /// Parameters:
    ///   - filters: Filters to scope the results. The following filters and logical operators are supported:    resourceArn - The ARN of the license configuration resource.    resourceType - The resource type (EC2_INSTANCE |  	EC2_HOST | EC2_AMI | SYSTEMS_MANAGER_MANAGED_INSTANCE).    resourceAccount - The ID of the account that owns the resource.
    ///   - licenseConfigurationArn: Amazon Resource Name (ARN) of the license configuration.
    ///   - maxResults: Maximum number of results to return in a single call.
    ///   - nextToken: Token for the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listUsageForLicenseConfiguration(
        filters: [Filter]? = nil,
        licenseConfigurationArn: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListUsageForLicenseConfigurationResponse {
        let input = ListUsageForLicenseConfigurationRequest(
            filters: filters, 
            licenseConfigurationArn: licenseConfigurationArn, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listUsageForLicenseConfiguration(input, logger: logger)
    }

    /// Rejects the specified grant.
    @Sendable
    @inlinable
    public func rejectGrant(_ input: RejectGrantRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RejectGrantResponse {
        try await self.client.execute(
            operation: "RejectGrant", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Rejects the specified grant.
    ///
    /// Parameters:
    ///   - grantArn: Amazon Resource Name (ARN) of the grant.
    ///   - logger: Logger use during operation
    @inlinable
    public func rejectGrant(
        grantArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RejectGrantResponse {
        let input = RejectGrantRequest(
            grantArn: grantArn
        )
        return try await self.rejectGrant(input, logger: logger)
    }

    /// Adds the specified tags to the specified resource. The following resources support tagging in License Manager:   Licenses   Grants   License configurations   Report generators
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds the specified tags to the specified resource. The following resources support tagging in License Manager:   Licenses   Grants   License configurations   Report generators
    ///
    /// Parameters:
    ///   - resourceArn: Amazon Resource Name (ARN) of the resource. The following examples provide an example ARN for each supported resource in License Manager:   Licenses - arn:aws:license-manager::111122223333:license:l-EXAMPLE2da7646d6861033667f20e895    Grants - arn:aws:license-manager::111122223333:grant:g-EXAMPLE7b19f4a0ab73679b0beb52707    License configurations - arn:aws:license-manager:us-east-1:111122223333:license-configuration:lic-EXAMPLE6a788d4c8acd4264ff0ecf2ed2d    Report generators - arn:aws:license-manager:us-east-1:111122223333:report-generator:r-EXAMPLE825b4a4f8fe5a3e0c88824e5fc6
    ///   - tags: One or more tags.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [Tag],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes the specified tags from the specified resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the specified tags from the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: Amazon Resource Name (ARN) of the resource.
    ///   - tagKeys: Keys identifying the tags to remove.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Modifies the attributes of an existing license configuration.
    @Sendable
    @inlinable
    public func updateLicenseConfiguration(_ input: UpdateLicenseConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateLicenseConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateLicenseConfiguration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Modifies the attributes of an existing license configuration.
    ///
    /// Parameters:
    ///   - description: New description of the license configuration.
    ///   - disassociateWhenNotFound: When true, disassociates a resource when software is uninstalled.
    ///   - licenseConfigurationArn: Amazon Resource Name (ARN) of the license configuration.
    ///   - licenseConfigurationStatus: New status of the license configuration.
    ///   - licenseCount: New number of licenses managed by the license configuration.
    ///   - licenseCountHardLimit: New hard limit of the number of available licenses.
    ///   - licenseRules: New license rule. The only rule that you can add after you create a license configuration is licenseAffinityToHost.
    ///   - name: New name of the license configuration.
    ///   - productInformationList: New product information.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateLicenseConfiguration(
        description: String? = nil,
        disassociateWhenNotFound: Bool? = nil,
        licenseConfigurationArn: String,
        licenseConfigurationStatus: LicenseConfigurationStatus? = nil,
        licenseCount: Int64? = nil,
        licenseCountHardLimit: Bool? = nil,
        licenseRules: [String]? = nil,
        name: String? = nil,
        productInformationList: [ProductInformation]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateLicenseConfigurationResponse {
        let input = UpdateLicenseConfigurationRequest(
            description: description, 
            disassociateWhenNotFound: disassociateWhenNotFound, 
            licenseConfigurationArn: licenseConfigurationArn, 
            licenseConfigurationStatus: licenseConfigurationStatus, 
            licenseCount: licenseCount, 
            licenseCountHardLimit: licenseCountHardLimit, 
            licenseRules: licenseRules, 
            name: name, 
            productInformationList: productInformationList
        )
        return try await self.updateLicenseConfiguration(input, logger: logger)
    }

    /// Updates a report generator. After you make changes to a report generator, it starts generating new reports within 60 minutes of being updated.
    @Sendable
    @inlinable
    public func updateLicenseManagerReportGenerator(_ input: UpdateLicenseManagerReportGeneratorRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateLicenseManagerReportGeneratorResponse {
        try await self.client.execute(
            operation: "UpdateLicenseManagerReportGenerator", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a report generator. After you make changes to a report generator, it starts generating new reports within 60 minutes of being updated.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
    ///   - description: Description of the report generator.
    ///   - licenseManagerReportGeneratorArn: Amazon Resource Name (ARN) of the report generator to update.
    ///   - reportContext: The report context.
    ///   - reportFrequency: Frequency by which reports are generated.
    ///   - reportGeneratorName: Name of the report generator.
    ///   - type: Type of reports to generate. The following report types are supported:   License configuration report - Reports the number and details of consumed licenses for a license configuration.   Resource report - Reports the tracked licenses and resource consumption for a license configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateLicenseManagerReportGenerator(
        clientToken: String,
        description: String? = nil,
        licenseManagerReportGeneratorArn: String,
        reportContext: ReportContext,
        reportFrequency: ReportFrequency,
        reportGeneratorName: String,
        type: [ReportType],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateLicenseManagerReportGeneratorResponse {
        let input = UpdateLicenseManagerReportGeneratorRequest(
            clientToken: clientToken, 
            description: description, 
            licenseManagerReportGeneratorArn: licenseManagerReportGeneratorArn, 
            reportContext: reportContext, 
            reportFrequency: reportFrequency, 
            reportGeneratorName: reportGeneratorName, 
            type: type
        )
        return try await self.updateLicenseManagerReportGenerator(input, logger: logger)
    }

    /// Adds or removes the specified license configurations for the specified Amazon Web Services resource. You can update the license specifications of AMIs, instances, and hosts. You cannot update the license specifications for launch templates and CloudFormation templates,  as they send license configurations to the operation that creates the resource.
    @Sendable
    @inlinable
    public func updateLicenseSpecificationsForResource(_ input: UpdateLicenseSpecificationsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateLicenseSpecificationsForResourceResponse {
        try await self.client.execute(
            operation: "UpdateLicenseSpecificationsForResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds or removes the specified license configurations for the specified Amazon Web Services resource. You can update the license specifications of AMIs, instances, and hosts. You cannot update the license specifications for launch templates and CloudFormation templates,  as they send license configurations to the operation that creates the resource.
    ///
    /// Parameters:
    ///   - addLicenseSpecifications: ARNs of the license configurations to add.
    ///   - removeLicenseSpecifications: ARNs of the license configurations to remove.
    ///   - resourceArn: Amazon Resource Name (ARN) of the Amazon Web Services resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateLicenseSpecificationsForResource(
        addLicenseSpecifications: [LicenseSpecification]? = nil,
        removeLicenseSpecifications: [LicenseSpecification]? = nil,
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateLicenseSpecificationsForResourceResponse {
        let input = UpdateLicenseSpecificationsForResourceRequest(
            addLicenseSpecifications: addLicenseSpecifications, 
            removeLicenseSpecifications: removeLicenseSpecifications, 
            resourceArn: resourceArn
        )
        return try await self.updateLicenseSpecificationsForResource(input, logger: logger)
    }

    /// Updates License Manager settings for the current Region.
    @Sendable
    @inlinable
    public func updateServiceSettings(_ input: UpdateServiceSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateServiceSettingsResponse {
        try await self.client.execute(
            operation: "UpdateServiceSettings", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates License Manager settings for the current Region.
    ///
    /// Parameters:
    ///   - enableCrossAccountsDiscovery: Activates cross-account discovery.
    ///   - organizationConfiguration: Enables integration with Organizations for cross-account discovery.
    ///   - s3BucketArn: Amazon Resource Name (ARN) of the Amazon S3 bucket where the License Manager information is stored.
    ///   - snsTopicArn: Amazon Resource Name (ARN) of the Amazon SNS topic used for License Manager alerts.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateServiceSettings(
        enableCrossAccountsDiscovery: Bool? = nil,
        organizationConfiguration: OrganizationConfiguration? = nil,
        s3BucketArn: String? = nil,
        snsTopicArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateServiceSettingsResponse {
        let input = UpdateServiceSettingsRequest(
            enableCrossAccountsDiscovery: enableCrossAccountsDiscovery, 
            organizationConfiguration: organizationConfiguration, 
            s3BucketArn: s3BucketArn, 
            snsTopicArn: snsTopicArn
        )
        return try await self.updateServiceSettings(input, logger: logger)
    }
}

extension LicenseManager {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: LicenseManager, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}
